package Note_for_class;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 姚东名
 * Date: 2024-05-02
 * Time: 21:58
 */
public class test0502 {
    public static void main(String[] args) {
        int a = 10;
        a+=1;
        System.out.println(a);//11

        int c = 10;
        long d = 20;
        //c =c + d;
        c += d;//自动帮你转换 不用手动进行转换
        System.out.println(c);//30
    }
    public static void main16(String[] args) {
        System.out.println(10 % 3);//1
        System.out.println(-10 % 3);//-1
        //在Java中 浮点数也是可以求模的
        System.out.println(11.5 % 2);//1.5
        System.out.println(1 + 2.0);//3.0
    }
    public static void main15(String[] args) {
        System.out.println(5 / 2);//2
        //System.out.println(5 / 0);分母不能为零 0
        //int -> String(整型变成字符串)
        int a = 100;
        String str = String.valueOf(a);
        System.out.println(str);
    }
    public static void main14(String[] args) {
        //字符串拼接：+
        int a = 10;
        System.out.println("a = " + a);

        int c = 20;
        System.out.println("a == " + a + c);//a == 1020
        //""字符串与+(加号)结合就是字符串
        System.out.println("a == " + (a + c));//a == 30
        //因为+(加号)与()d的结合 高于 +(加号)与""(字符串) 所以 (a + c)就先加起来了
        System.out.println(a + c + " = a + c");//30 = a + c
    }

    public static void main13(String[] args) {
        //int -> String
        int num = 100;
        //方法1：
        String str1 = num + "";
        System.out.println(str1);
        //方法2：使用方法：valueOf -> int转String
        String str2 = String.valueOf(num);
        System.out.println(str2);

    }

    public static void main12(String[] args) {
        String s = "123";
        //使用方法：parseInt -> String转int
        int a = Integer.parseInt(s);
        System.out.println(a + 1);//124

        String str = "100";
        int num = Integer.parseInt(str);
        System.out.println(num + 1);//101
    }

    public static void main11(String[] args) {
        //字符串 String
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1);
        System.out.println(s2);
        //字符串拼接：使用加号 可以对字符串进行拼接
        System.out.println(s1 + " " + s2);//hello world
    }

    public static void main10(String[] args) {
        //byte与byte的运算：
        byte a = 10;
        byte b = 20;
        //byte c  = a + b;
        //编译错误，因为byte与byte进行运算时，会进行整型提升。由于计算机的CPU通常是按照4个字节为单位从内存中读取数据，会将小的内存单位转换为int类型。再参与计算
        int c = a + b;
        byte d = (byte) (a + b);//不建议使用强制类型转换操作符
        System.out.println(c);
        System.out.println(d);
        /*小结：
        1.不同类型的数据进行混合运算，范围小的会提升为范围大的。
        2.对于short、byte这种比4个字节小的类型，会先提升为4个字节的int类型，再运算
         */

    }

    public static void main9(String[] args) {
        int a = 10;
        long b = 20;
        //进行类型提升：int -> long 把小的转换为大的类型
        int c1 = (int) (a + b);//不建议使用强制类型转换(这是人为进行的)
        long c2 = a + b;
        System.out.println(c1);
        System.out.println(c2);
    }

    public static void main8(String[] args) {
        //boolean类型：没有明确说明 大小是多少个字节？
        boolean b = true;
        System.out.println(b);
        //包装类：boolean -> Boolean
    }

    public static void main7(String[] args) {
        //char 类型是2个字节 Unicode字符集
        char ch1 = 'a';
        char ch2 = '哈';
        System.out.println(ch1);
        System.out.println(ch2);
        //包装类：char -> Character
        System.out.print(Character.MIN_RADIX + " ");
        System.out.println(Character.MAX_RADIX);
    }

    public static void main6(String[] args) {
        //双度浮点数：double
        double d = 12.5;
        System.out.println(d);

        double a = 1;
        double b = 2;
        System.out.println(a / b);//0.5

        double num = 1.1;
        System.out.println(num * num);//1.2100000000000002
        /*浮点数与整数在内存中的存储方式不同，不能单纯使用2^n的形式来计算
        double 类型的内存布局遵守 IEEE 754标准，尝试使用有限的内存空间表示可能无限的小数，会有精度的误差
        因此浮点数是一个近似值，不是准确值
        */

        float f = 12.3F;
        System.out.println(f);
    }

    public static void main5(String[] args) {
        //字节型：byte：1个字节 -> 8个bit位
        byte a = 9;
        System.out.println(a);
        //包装类：byte -> Byte
        System.out.print(Byte.MAX_VALUE + " ");
        System.out.println(Byte.MIN_VALUE);
        //127 -128(-2^8 ~ 2^8 - 1)
    }

    public static void main4(String[] args) {
        //short 短整型 2个字节 = 16个bit位
        short sh = 10;
        System.out.println(sh);
        //包装类：short -> Short
        System.out.print(Short.MAX_VALUE + " ");
        System.out.println(Short.MIN_VALUE);
        //32767 -32768(-2^16 ~ 2^16 - 1)
    }

    public static void main3(String[] args) {
        //long 长整型：8个字节 -> 64bit位
        long a = 10L;
        System.out.println(a);
        //包装类：long -> Long
        System.out.print(Long.MAX_VALUE + " ");
        System.out.println(Long.MIN_VALUE);
        //9223372036854775807 -9223372036854775808(-2^63 ~ 2^63 - 1)
    }

    public static void main2(String[] args) {
        //数据类型+变量
        int a = 10;//定义的同时进行了初始化
        System.out.println(a);
        //包装类：int -> Integer(int 的plus版本)
        System.out.print(Integer.MIN_VALUE + " ");
        System.out.println(Integer.MAX_VALUE);
        //-2147483648 ~ 2147483647(-2^31 ~ 2^31 - 1)

        Integer b = 10;
        System.out.println(b);

        int c;//定义
        c = 20;//初始化
        System.out.println(c);

    }

    public static void main1(String[] args) {
        System.out.println(10);
        //C语言中的const与java中的final一样的意思，使字面常量无法被改变，变成了常量
        final int SIZE = 10;
        System.out.println(SIZE);
        //SIZE = 20;//发生报错

        /*基本数据类型，一共8种：
        整型：byte、short、int、long
        浮点型：float、double
        字符：char
        布尔类型：boolean

        在C语言与在Java中不一样，不管你是多少位系统 Java当中的数据类型 占用的字节数 是一定的 不分有符号的数据还是无符号的数据
        好处：可移植性高
        */

    }
}
